NUT-XX wallet quote lookup: wire-contract fixes, signed lookups with persistence, mintable-only filter - #9

get_mint_quote_by_public_key imported unique_string through the test
module root, where the helper is not re-exported (it is private to this
module and already in scope). Any build that enables cdk-common's
"test" feature - the sqlite backend's test suite, for one - failed to
compile on the unresolved path. Delete the import; calls resolve to the
module-level definition directly.

The wallet's mint_quote table gained a created_time column (for
ordering) whose value was never written: add_mint_quote's INSERT omits
the column, so every row keeps the schema default of 0. The in-memory
MintQuote struct does not carry the field, so no construction site -
mint_quote, fetch_mint_quote, or any other path that funnels into
add_mint_quote - could populate it either.

The mint's NUT-04 responses carry no creation time, so the honest value
is the wallet's own first sighting: bind unix_time() in the INSERT, the
same way the p2pk_signing_key insert in this module already stamps its
created_time. The column stays out of the ON CONFLICT UPDATE clause,
so re-storing an existing quote preserves the original first-store
time. Fixing the single shared store path covers every quote
construction site at once.

The regression test reads the column back over a raw connection, since
the public struct does not expose it, and plants a sentinel before a
second store to prove updates preserve rather than restamp it.

Give the wallet a high-level entry point for the NUT-XX lookup: sign,
fetch, validate, and store, so callers get reconciled MintQuote records
instead of raw connector responses. Modeled on fetch_mint_quote (cdk
convention: fetch_ = fetch-and-store).

- The mint's NUT-06 pubkey binds the signatures to this mint; a mint
  that does not advertise one fails fast with Error::MissingPubkey.
- secret_keys are deduplicated by pubkey before the request is built,
  so duplicates don't burn slots of the MAX_LOOKUP_PUBKEYS budget, and
  an empty set short-circuits without any network call.
- Every returned quote is checked against the requested pubkeys; a
  quote with a missing or unrequested pubkey is logged and dropped
  rather than stored, since this method writes mint responses to the
  wallet database and cannot take the mint's word for whose they are.
- Reconciliation reuses apply_mint_quote_response and constructs
  unseen quotes exactly as fetch_mint_quote does, then stamps the
  signing key. Writes are change-guarded: apply_mint_quote_response's
  bool means "not stale", not "changed" - it reports true for a
  byte-identical repeat - so the guard compares the fields the
  response can touch before and after instead. A caller polling on an
  interval must not rewrite an unchanged quote history on every pass.

The mock connector now captures lookup requests and counts
get_mint_info calls so tests can assert what actually went out. Tests
cover sign/verify round-trip and mint-binding, the oversized-batch
error, store-and-stamp behavior, the unrequested-pubkey drop, the
missing-mint-pubkey failure, the empty-input short-circuit, and write
idempotency witnessed through the quote row's optimistic-concurrency
version.

Add an opt-in request filter so callers can bound the pubkey lookup
response to quotes that are still mintable (amount_paid >
amount_issued). The wire format is additive and backward compatible:
only_mintable is absent from the wire when false (skip_serializing_if),
so a mint that predates the field sees the request an old client would
send, and an old client deserializing a request defaults it to false.

Threads the flag from Wallet::fetch_mint_quotes_by_pubkey through the
NUT-XX request, the axum handler, Mint::get_mint_quote_by_pubkey, and
the mint database trait down to the SQL query, which adds
"AND amount_paid > amount_issued" to the WHERE clause when set - this
also skips the per-quote payments/issuance follow-up queries for
excluded rows. The filter is a response-bounding convenience only: it
is not part of the NUT-20 signed message and carries no security
weight. The mint logs one debug line after the query with the pubkey
and result counts and the flag, so operators can see lookup traffic
without turning on request tracing.

Serde tests pin all three wire shapes (absent, false, true). The
wallet test asserts the flag lands on the outgoing request verbatim,
and mint-side integration coverage creates three quotes for one key -
unpaid, paid-unissued, fully-issued - and checks the filter returns
exactly the paid-unissued one when set, and all three when not.

Exercise Wallet::fetch_mint_quotes_by_pubkey against a real in-process
Mint through the existing DirectMintConnection: the wallet signs its own
lookup challenge, the mint verifies it, and the returned quote lands in
the wallet database with its signing key stamped. A negative case covers
a key with no quotes (empty result, not an error).

Lives in cdk-integration-tests rather than crates/cdk/tests so it reuses
the complete direct connector instead of a stub-heavy local one.

A cached mint record can lack a pubkey while still satisfying the
metadata cache: it may predate the mint advertising one, or the stored
form may fail to parse (the wallet store currently persists this column
in an encoding its reader does not accept, reported separately).
Trusting the cache meant fetch_mint_quotes_by_pubkey failed with
MissingPubkey forever, starving a polling caller even though the live
mint advertises a pubkey.

Fall back to one forced fetch_mint_info refresh before erroring, which
restores the pubkey for the life of the process. A mint that genuinely
has no pubkey still fails with MissingPubkey after the refresh.